package com.ruoyi.service.impl;

import java.util.List;
import java.util.ArrayList;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.mapper.CarGasStationMapper;
import com.ruoyi.domain.CarGasStation;
import com.ruoyi.service.ICarGasStationService;

/**
 * 加油站Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-01-27
 */
@Service
public class CarGasStationServiceImpl implements ICarGasStationService 
{
    @Autowired
    private CarGasStationMapper carGasStationMapper;

    /**
     * 查询加油站
     * 
     * @param gasStationId 加油站主键
     * @return 加油站
     */
    @Override
    public CarGasStation selectCarGasStationById(Integer gasStationId)
    {
        return carGasStationMapper.selectCarGasStationById(gasStationId);
    }

    /**
     * 查询加油站列表
     * 
     * @param carGasStation 加油站
     * @return 加油站集合
     */
    @Override
    public List<CarGasStation> selectCarGasStationList(CarGasStation carGasStation)
    {
        return carGasStationMapper.selectCarGasStationList(carGasStation);
    }

    /**
     * 根据经纬度查询附近加油站
     * 
     * @param latitude 纬度
     * @param longitude 经度
     * @param radius 搜索半径（米）
     * @return 加油站列表
     */
    @Override
    public List<CarGasStation> selectNearbyGasStations(String latitude, String longitude, Integer radius)
    {
        try {
            System.out.println("=== 开始查询附近加油站 ===");
            System.out.println("用户位置: 纬度=" + latitude + ", 经度=" + longitude + ", 半径=" + radius + "m");
            
            // 获取所有未删除的加油站
            CarGasStation query = new CarGasStation();
            query.setDeleted(0);
            List<CarGasStation> allStations = carGasStationMapper.selectCarGasStationList(query);
            
            System.out.println("数据库查询结果: 找到" + allStations.size() + "个加油站");
            
            // 计算距离并筛选在指定半径内的加油站
            double userLat = Double.parseDouble(latitude);
            double userLng = Double.parseDouble(longitude);
            double radiusKm = radius / 1000.0; // 转换为公里
            
            System.out.println("用户坐标转换: 纬度=" + userLat + ", 经度=" + userLng + ", 半径=" + radiusKm + "km");
            
            List<CarGasStation> nearbyStations = new ArrayList<>();
            
            for (CarGasStation station : allStations) {
                System.out.println("处理加油站: " + station.getName() + 
                                 ", 坐标: (" + station.getLatitude() + ", " + station.getLongitude() + ")");
                
                if (station.getLatitude() != null && station.getLongitude() != null) {
                    try {
                        double stationLat = Double.parseDouble(station.getLatitude());
                        double stationLng = Double.parseDouble(station.getLongitude());
                        
                        System.out.println("加油站坐标转换: 纬度=" + stationLat + ", 经度=" + stationLng);
                        
                        // 计算距离（使用简单的欧几里得距离，实际项目中建议使用Haversine公式）
                        double distance = calculateDistance(userLat, userLng, stationLat, stationLng);
                        
                        System.out.println("计算距离: " + distance + "km");
                        
                        if (distance <= radiusKm) {
                            // 设置计算出的距离（用于排序）
                            station.setDistance(distance);
                            nearbyStations.add(station);
                            System.out.println("加油站" + station.getName() + "在范围内，距离: " + distance + "km");
                        } else {
                            System.out.println("加油站" + station.getName() + "超出范围，距离: " + distance + "km > " + radiusKm + "km");
                        }
                    } catch (NumberFormatException e) {
                        // 跳过坐标格式不正确的加油站
                        System.err.println("加油站坐标格式错误: " + station.getName() + ", lat: " + station.getLatitude() + ", lng: " + station.getLongitude());
                    }
                } else {
                    System.out.println("加油站" + station.getName() + "坐标为空");
                }
            }
            
            // 按距离排序
            nearbyStations.sort((a, b) -> Double.compare(a.getDistance(), b.getDistance()));
            
            System.out.println("=== 查询完成 ===");
            System.out.println("最终结果: 找到" + nearbyStations.size() + "个附近加油站");
            for (CarGasStation station : nearbyStations) {
                System.out.println("- " + station.getName() + ": 距离" + station.getDistance() + "km");
            }
            
            return nearbyStations;
        } catch (Exception e) {
            System.err.println("查询附近加油站失败: " + e.getMessage());
            e.printStackTrace();
            return new ArrayList<>();
        }
    }
    
    /**
     * 根据地址关键词搜索加油站
     * 
     * @param keyword 搜索关键词
     * @return 加油站列表
     */
    @Override
    public List<CarGasStation> searchGasStationsByKeyword(String keyword)
    {
        try {
            // 创建查询条件
            CarGasStation query = new CarGasStation();
            query.setDeleted(0);
            
            // 如果有关键词，设置地址搜索条件
            if (keyword != null && !keyword.trim().isEmpty()) {
                query.setAddress(keyword.trim());
            }
            
            List<CarGasStation> stations = carGasStationMapper.selectCarGasStationList(query);
            
            System.out.println("搜索加油站: 关键词='" + keyword + "', 找到" + stations.size() + "个加油站");
            
            return stations;
        } catch (Exception e) {
            System.err.println("搜索加油站失败: " + e.getMessage());
            e.printStackTrace();
            // 如果出错，返回空列表
            return new ArrayList<>();
        }
    }
    
    /**
     * 新增加油站
     * 
     * @param carGasStation 加油站
     * @return 结果
     */
    @Override
    public int insertCarGasStation(CarGasStation carGasStation)
    {
        carGasStation.setDeleted(0);
        return carGasStationMapper.insertCarGasStation(carGasStation);
    }

    /**
     * 修改加油站
     * 
     * @param carGasStation 加油站
     * @return 结果
     */
    @Override
    public int updateCarGasStation(CarGasStation carGasStation)
    {
        return carGasStationMapper.updateCarGasStation(carGasStation);
    }

    /**
     * 批量删除加油站
     * 
     * @param gasStationIds 需要删除的加油站主键
     * @return 结果
     */
    @Override
    public int deleteCarGasStationByIds(Integer[] gasStationIds)
    {
        return carGasStationMapper.deleteCarGasStationByIds(gasStationIds);
    }

    /**
     * 删除加油站信息
     * 
     * @param gasStationId 加油站主键
     * @return 结果
     */
    @Override
    public int deleteCarGasStationById(Integer gasStationId)
    {
        return carGasStationMapper.deleteCarGasStationById(gasStationId);
    }

    /**
     * 获取加油站价格信息
     * 
     * @param gasStationId 加油站ID
     * @return 价格信息
     */
    @Override
    public Object getGasStationPrices(Integer gasStationId)
    {
        // 这里需要查询加油站价格表
        // 暂时返回空对象
        return null;
    }
    
    /**
     * 计算两点间的距离（公里）
     * 使用简化的距离计算公式，实际项目中建议使用Haversine公式
     */
    private double calculateDistance(double lat1, double lng1, double lat2, double lng2) {
        // 简化的距离计算（实际项目中建议使用Haversine公式）
        double deltaLat = lat2 - lat1;
        double deltaLng = lng2 - lng1;
        return Math.sqrt(deltaLat * deltaLat + deltaLng * deltaLng) * 111.0; // 1度约等于111公里
    }
}
